import Scanner from "./Scanner";

// 将生成的平级tokens => 嵌套tokens（通过栈的思维）
function initTokens (tokens) {
    // 栈1
    let stack1 = []
    // 栈2
    let stack2 = []
    // 指针
    let pos = 0

    while (pos < tokens.length) {
        // 1 获取初始值
        let value = tokens[pos]
        let word = value[0]
        // 2 判断值
        let text_tag = Boolean(word === 'text')
        let arr_tag = Boolean(word === '#')
        let end_tag = Boolean(word === '/')
        // 3 进栈
        if (text_tag) {
            // 栈2弹栈
            if (stack1.length != 0) {
                // 改变栈2末尾值
                stack2[stack2.length - 1][2].push(value);
            }
            else {
                // 栈2进栈
                stack2.push(value)
            }
        }
        else if (arr_tag) {
            // 栈1进栈
            stack1.push(word)
            // 初始值推进一个空数组
            value.push([])
            // 栈2进栈
            stack2.push(value)
        }
        else if (end_tag) {
            // 栈1出栈
            stack1.pop()
            if (stack1.length != 0) {
                // 将栈2最后的值（n）推进（n-1）的值内
                let arr = stack2.pop()
                stack2[stack2.length - 1][2].push(arr);
            }
        }
        pos++
    }
}
// 源码实现（使用一个收集器，收集完成后切换指向）
function originInitTokens (tokens) {
    let result = []                     // 结果数组
    let stack = []                      // 栈结构，存放特殊token（#...）
    let collector = result              // 收集器

    for (const token of tokens) {
        switch (token[0]) {
            case '#':
                collector.push(token)           // 放入收集器
                stack.push(token)               // 推入栈
                collector = token[2] = []       // 改变收集器指向，指向 子元素的容器
                break;
            case '/':
                stack.pop()         // 出栈
                collector = stack.length > 0 ? stack[stack.length - 1][2] : result // 改变收集器指向
                break;
            default:
                collector.push(token);
        }
    }
    return result
}


export default function parseTemplateToTokens (template) {
    let tokens = []
    // 1 创建扫描器
    let scanner = new Scanner(template);
    // 2 开始扫扫描
    scanner.startScan(tokens)
    // 3 生成的平级tokens => 嵌套tokens（通过栈的思维）
    // tokens = initTokens(tokens)
    return originInitTokens(tokens)
}